#include <string.h>

#include "Globales.h"
#include "TDiccionario.h"

#define CANT_INICIAL 15
#define ERROR_ALOCAR_MEMORIA -1
#define ERROR 2

int TDiccionario_Crear(TDiccionario* td){
    int iError=0;
    td->m_iTamanioDato = sizeof(TClave_Valor);
    td->m_xArray=malloc( CANT_INICIAL * (td->m_iTamanioDato));
    if (!td->m_xArray)
    return ERROR_ALOCAR_MEMORIA;
    td->m_iSize= CANT_INICIAL;
    td->m_iIndice=0;
    return iError;
}

int TDiccionario_Destruir(TDiccionario* td){
    int iError;
    free(td->m_xArray);
    td->m_xArray=NULL;
    return iError;
    }

int Add(TDiccionario* td, TClave_Valor* elemento){
    TClave_Valor* aux;
    TClave_Valor* aux2;
    if (td->m_iSize == td->m_iIndice){
        aux= (TClave_Valor*) malloc((2*td->m_iSize)*( td->m_iTamanioDato));
        if (!aux)
        return ERROR_ALOCAR_MEMORIA;
        td->m_iSize=td->m_iSize*2;
        memcpy(aux, td->m_xArray, td->m_iIndice * td->m_iTamanioDato);
        free(td->m_xArray);
        td->m_xArray=aux;
        }
    aux2= (td->m_xArray) + (td->m_iIndice * td->m_iTamanioDato);
    memcpy(aux2, elemento, td->m_iTamanioDato);
    td->m_iIndice++;
    return 0;
    }

int TDiccionario_Busqueda(TDiccionario* td, char* clave){
    int primer=0;
    int ultimo= td->m_iIndice;
    int central= (primer + ultimo)/2;
    eBoolean eEncontrado= ebFalse;
    TClave_Valor* posicion;
    TClave_Valor dato;

        while((!eEncontrado) && (primer<ultimo)){
            posicion= td->m_xArray + (central * td->m_iTamanioDato);
            dato= *posicion;
            if (strcmp(dato.m_szClave,clave) == 0)
              eEncontrado = ebTrue;
            else{
                if (strcmp(dato.m_szClave, clave) < 0)
                primer = central + 1;
                else ultimo = central - 1;
                }
            }
    if (eEncontrado == ebTrue)
    return central;
    else return -1;
    }

int Set(TDiccionario* td, int pos, TClave_Valor* elem){
    int iError=0;
    TClave_Valor* aux;
    if ((pos<0) || (pos>= td->m_iIndice))
    return ERROR;
    aux= (td->m_xArray)+ (pos * td->m_iTamanioDato);
    memcpy(aux,elem,td->m_iTamanioDato);
    return iError;
    }

int TDiccionario_colocar(TDiccionario* td, char* clave, char* valor){
    int iError=0;
    TClave_Valor* elemento;
    int posicionClave;
    strcpyMem( elemento->m_szClave, clave);
    strcpyMem( elemento->m_szValor, valor);

    if ( td->m_iIndice == 0){
    iError= Add( td , elemento);
    }
    else{
        posicionClave= TDiccionario_Busqueda( td, clave);
        if (posicionClave != -1){
            iError= Set(td, posicionClave, elemento);
            }
        else  iError = Add( td, elemento);
        }
    return iError;
    }


int TDiccionario_sizeDato(TDiccionario* td, char* clave){
    int iTamanio;
    int posicionClave = TDiccionario_Busqueda( td, clave);
    if (posicionClave != -1){
        TClave_Valor* elemento;
        elemento= (td->m_xArray) + (posicionClave * td->m_iTamanioDato);
        iTamanio= sizeof(*elemento->m_szValor);
        return iTamanio;
        }
     else return 0;
    }

int TDiccionario_obtener(TDiccionario* td, char* clave, char* buffer){
    int iError = 0;
    TClave_Valor* elemento;
    int posicionClave = TDiccionario_Busqueda( td, clave);
    elemento = (td->m_xArray) + (posicionClave * td->m_iTamanioDato);
    memcpy( buffer, elemento->m_szValor , TDiccionario_sizeDato(td,clave));
    return iError;
    }

